package com.javawork.juc.three;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 一个线程不应该由其他线程来强制中断或停止，而是应该由线程自行停止，自己决定自己的命运
 * 所以，Thread.stop,Thread.suspend,Thread.resume都已经被废弃了；
 * <br/>
 * 在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。
 * 因此，Java提供了一种用于停止线程的协商机制——中断，也即中断标识协商机制。
 * <br/>
 * 中断只是一种协作协商机制，Java没有给中断增加任何语法，中断的过程完全需要程序员自己实现。
 * 若要中断一个线程，需要手动调用该线程的interrupt方法，该方法也仅仅是将线程对象的中断标识设置为true；
 * <br/>
 * 每个线程对象都有一个中断标识位，用于表示线程是否被中断；该标识位为true表示中断，false表示未中断；
 * 通过调用线程的interrupt方法将该线程的标识位设为true，可以在别的线程中调用，也可在自己的线程中调用
 * <br/>
 * 具体来说，当对一个线程，调用interrupt（）时：
 * ①如果线程处于正常活动状态，那么会将该线程的中断标志设置为true，仅此而已。
 * 被设置中断标志的线程将继续正常运行，不受影响。
 * 所以，interrupt（）并不能真正的中断线程，需要被调用的线程自己进行配合才行。
 * ②如果线程处于被阻塞状态（例如处于sleep，wait，join等状态），在别的线程中调用当前线程对象的interrupt方法，
 * 那么线程将立即退出被阻塞状态，并抛出一个InteruptedException异常。
 * @author zhangxiaolu
 * @since 2023-02-08 22:06
 */
public class InterruptDemo {

    /**
     * 1.如何停止中断运行中的线程？
     * 1.1通过volatile变量实现
     * 1.2通过AtomicBoolean
     * 1.3通过Thread类自带的中断Api实例方法实现
     */

    static volatile boolean isStop = false;
    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);

    public static void main(String[] args) {
//        m1_volatile();
//        m2_AtomicBoolean();
        m3_ThreadApi();
    }

    private static void m1_volatile() {
        new Thread(() -> {
            while (true) {
                if (isStop) {
                    System.out.println("isStop被修改为true，线程停止");
                    break;
                }
                System.out.println("t1.....hello volatile");
            }
        }, "t1").start();

        try {
            TimeUnit.MILLISECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> isStop = true, "t2").start();
    }

    private static void m2_AtomicBoolean() {
        new Thread(() -> {
            while (true) {
                if (atomicBoolean.get()) {
                    System.out.println("atomicBoolean被修改为true，线程停止");
                    break;
                }
                System.out.println("t3.....hello atomicBoolean");
            }
        }, "t3").start();

        try {
            TimeUnit.MILLISECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> atomicBoolean.set(true), "t4").start();
    }

    /**
     * interrupt()
     * interrupted()
     * isInterrupted()
     */
    private static void m3_ThreadApi() {
        Thread t5 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("isInterrupted()被修改为true，程序停止");
                    break;
                }
                System.out.println("t5----hello ThreadApi");
            }
        }, "t5");
        t5.start();
        System.out.println("----t5的默认中断标志位：" + t5.isInterrupted());
        try {
            TimeUnit.MILLISECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(t5::interrupt, "t6").start();
    }
}
